package day04;

import java.util.Arrays;

//数组
public class ArrayDemo {
    public static void main(String[] args) {
        /*
        什么是数组：数据的组合

        数组的概念：
            相同数据类型元素（数据）的集合
            是一种引用数据类型
            将一组类型相同、逻辑相关的数据，存到数组中

        定义数组
            int a;      //声明一个整型变量，名为a
            int[] b;    //声明一个整型数组变量，名为b

            int a=5;
            int[] b=5;//编译错误，数据类型不匹配
            int[] b = new int[4];
        定义数组的语法：
            数据类型[] 数组名 = new 数据类型[大小]；
                1）int[] a = new int[3];
                //声明整型数组a，包含3个元素，每个元素都是int类型，默认值为0
                2)double[] d = new double[10];
                //声明浮点型数组d，包含10个元素，每个元素都是double类型，默认值为0.0
                3)boolean[] b = new boolean[26];
                //声明布尔型数组b，包含26个元素，每个元素都是boolean类型，默认值为false

        数组元素默认值规则：
        1）byte、short、int、long、char----------默认值为0
        2）float、double------------------------默认值为0.0
        3）boolean------------------------------默认值为false
         */

        /*
        //数组的定义：
        int[] a = new int[5];
        //声明整型数组a，包含3个元素，每个元素都是int类型，默认值为0
        double[] d = new double[10];
        //声明浮点型数组d，包含10个元素，每个元素都是double类型，默认值为0.0
        boolean[] b = new boolean[26];
        //声明布尔型数组b，包含26个元素，每个元素都是boolean类型，默认值为false
         */

        /*
        数组的初始化
            初始化数据：
                给元素初始化：
                    1）int[] arr = new int[3];//0,0,0
                    2)int[] arr = {2,5,8};//2,5,8
                    3)int[] arr = new int[]{2,5,8};//2,5,8  []里不能写元素个数了
                    4)int[] arr;
                        arr = {2,5,8};          //编译错误，此方式只能声明同时初始化
                        arr = new int[]{2,5,8}; //正确
         */

        /*
        数组的访问
            数组的长度即元素的个数
                通过数组名.length可以获取数组的长度
                    int[] arr = new int[3];
                    System.out.println("数组的长度为"+arr.length);    //数组的长度为：3
                    System.out.println("数组第1个元素为："+arr[0]);    //0
                    arr[0] = 100;                                  //给第1个元素赋值为100
                    arr[1] = 200;                                  //给第2个元素赋值为200
                    arr[2] = 300;                                  //给第3哥元素赋值为300
                    arr[3] = 400;                                  //运行时会发生数组下越界异常
                    System.out.println(arr[2]);                    //300,输出最后一个元素的值
                    System.out.println(arr[arr.length-1]);         //300,输出最后一个元素的值

                通过下标/索引访问数组的元素，下标从0开始，最大到（长度-1）
                    int[] arr new int[3];//0,0,0
                    //给每个元素标个号
                    arr[0]------------------------>代表arr中的第1个元素（int）
                    arr[1]------------------------>代表arr中的第2个元素（int）
                    arr[2]------------------------>代表arr中的第3个元素（int）
                    //给第2个元素赋值为100
                    arr[1] = 100；
         */

        /*
        数组的遍历
            遍历数组
                遍历/迭代：从头到尾挨个走一遍
                    int[] arr = new int[10];//需求：给每个元素都赋值为100
                    for(int i=0;i<arr.length;i++){          //遍历arr数组
                        arr[i] = 100;                       //给每个元素赋值为100
                        System.out.println(arr[i]);         //输出每个元素的值
                    }
                    for(int i=0;i<arr.length;i++){          //遍历arr数组
                        arr[i] = (int)(Math.random()*100);  //给每个元素赋值为0到99的随机数
                        System.out.println(arr[i]);         //输出每个元素的值
                    }
         */

        /*
        数组的复制：
            System.arraycopy()数组的复制//灵活性好
                使用System.arraycopy();可以实现数组的复制
                    int[] a = {10,20,30,40,50};
                    int[] b = new int[6];//0,0,0,0,0,0
                    System.arraycopy(a,1,b,0,4);
                    //a:源数组  1:源数组的起始下标  b:目标数组  0:目标数组的起始下标  4：要复制的元素个数
                    for (int i=0;i<b.length;i++){
                        System.out.println(b[i]);
                    }
             Arrays.copyOf()数组的复制//灵活性差
                使用Arrays.copyOf()可以实现数组的复制
                    int[] a = {10,20,30,40,50};
                    int[] b = Arrays.copyOf(a,6);
                    //若目标数组长度>源数组长度，则末尾补默认值
                    int[] c = Arrays.copyOf(a,4);
                    //若目标数组长度<源数组长度，则将末尾的截掉
                    //a:源数组
                    //b:目标数组
                    //6：目标数组的长度
                    for (int i=0;i<b.length;i++){
                        System.out.println(b[i]);
                    }
                    System.out.println("--------------------");
                    for (int i=0;i<c.length;i++){
                        System.out.println(c[i]);
                    }
                 数组的扩容
                    数组的长度在创建数组后是不可改变的，数组元素的内存空间是连续的
                    所谓扩容是指创建一个更大的新数组并将源数组的内容复制进去
                        int[] a = {10,20,30,40,50};//20个字节
                        a = Arrays.copyOf(a,a.length+1);//扩容
                        for (int i=0;i<a.length;i++){
                            System.out.println(a[i]);
                        }
                 //求数组元素的最大值，并将其存储到数组最后一个元素的下一个位置
                    int[] arr = new int[10];
                    for (int i=0;i<arr.length;i++){
                        arr[i] = (int)(Math.random()*100);
                        System.out.println(arr[i]);
                    }
                    //找最大值：
                    int max = arr[0];               //假设第1个元素为最大值
                    for (int i=1;i<arr.length;i++){ //遍历剩余元素
                        if (arr[i]>max){            //若剩余元素大于max
                            max=arr[i];             //将max修改为较大的
                        }
                    }
                    System.out.println("最大值为："+max);

                    arr = Arrays.copyOf(arr,arr.length+1);//扩容
                    arr[arr.length-1] = max;//将最大值max赋值到最后一个元素上
                    for (int i=0;i<arr.length;i++){
                        System.out.println(arr[i]);
                    }
         */


    }
}
